/*
 * Copyright 2013 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.netty.util.concurrent;

import java.util.Queue;
import java.util.concurrent.Callable;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

@SuppressWarnings("ComparableImplementedButEqualsNotOverridden")
final class ScheduledFutureTask<V> extends PromiseTask<V>
        implements ScheduledFuture<V>
{
    private static final AtomicLong nextTaskId = new AtomicLong();

    private static final long START_TIME = System.nanoTime();

    static long nanoTime()
    {
        return System.nanoTime() - START_TIME;
    }

    static long deadlineNanos(long delay)
    {
        return nanoTime() + delay;
    }

    private final long id = nextTaskId.getAndIncrement();

    private long deadlineNanos;

    /* 0 - no repeat, >0 - repeat at fixed rate, <0 - repeat with fixed delay */
    private final long periodNanos;

    ScheduledFutureTask(AbstractScheduledEventExecutor executor,
            Runnable runnable, V result, long nanoTime)
    {

        this(executor, toCallable(runnable, result), nanoTime);
    }

    ScheduledFutureTask(AbstractScheduledEventExecutor executor,
            Callable<V> callable, long nanoTime, long period)
    {

        super(executor, callable);
        if (period == 0)
        {
            throw new IllegalArgumentException("period: 0 (expected: != 0)");
        }
        deadlineNanos = nanoTime;
        periodNanos = period;
    }

    ScheduledFutureTask(AbstractScheduledEventExecutor executor,
            Callable<V> callable, long nanoTime)
    {

        super(executor, callable);
        deadlineNanos = nanoTime;
        periodNanos = 0;
    }

    @Override
    protected EventExecutor executor()
    {
        return super.executor();
    }

    public long deadlineNanos()
    {
        return deadlineNanos;
    }

    public long delayNanos()
    {
        return Math.max(0, deadlineNanos() - nanoTime());
    }

    public long delayNanos(long currentTimeNanos)
    {
        return Math.max(0, deadlineNanos() - (currentTimeNanos - START_TIME));
    }

    @Override
    public long getDelay(TimeUnit unit)
    {
        return unit.convert(delayNanos(), TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed o)
    {
        if (this == o)
        {
            return 0;
        }

        ScheduledFutureTask<?> that = (ScheduledFutureTask<?>) o;
        long d = deadlineNanos() - that.deadlineNanos();
        if (d < 0)
        {
            return -1;
        }
        else if (d > 0)
        {
            return 1;
        }
        else if (id < that.id)
        {
            return -1;
        }
        else if (id == that.id)
        {
            throw new Error();
        }
        else
        {
            return 1;
        }
    }

    @Override
    public void run()
    {
        assert executor().inEventLoop();
        try
        {
            if (periodNanos == 0)
            {
                if (setUncancellableInternal())
                {
                    V result = task.call();
                    setSuccessInternal(result);
                }
            }
            else
            {
                // check if is done as it may was cancelled
                if (!isCancelled())
                {
                    task.call();
                    if (!executor().isShutdown())
                    {
                        long p = periodNanos;
                        if (p > 0)
                        {
                            deadlineNanos += p;
                        }
                        else
                        {
                            deadlineNanos = nanoTime() - p;
                        }
                        if (!isCancelled())
                        {
                            // scheduledTaskQueue can never be null as we lazy
                            // init it before submit the task!
                            Queue<ScheduledFutureTask<?>> scheduledTaskQueue = ((AbstractScheduledEventExecutor) executor()).scheduledTaskQueue;
                            assert scheduledTaskQueue != null;
                            scheduledTaskQueue.add(this);
                        }
                    }
                }
            }
        }
        catch (Throwable cause)
        {
            setFailureInternal(cause);
        }
    }

    @Override
    public boolean cancel(boolean mayInterruptIfRunning)
    {
        boolean canceled = super.cancel(mayInterruptIfRunning);
        if (canceled)
        {
            ((AbstractScheduledEventExecutor) executor()).removeScheduled(this);
        }
        return canceled;
    }

    boolean cancelWithoutRemove(boolean mayInterruptIfRunning)
    {
        return super.cancel(mayInterruptIfRunning);
    }

    @Override
    protected StringBuilder toStringBuilder()
    {
        StringBuilder buf = super.toStringBuilder();
        buf.setCharAt(buf.length() - 1, ',');

        return buf.append(" id: ").append(id).append(", deadline: ")
                .append(deadlineNanos).append(", period: ").append(periodNanos)
                .append(')');
    }
}
